#include <string.h>
#include <stdio.h>
#include "mhscpu.h"

/* Private function prototypes -----------------------------------------------*/
#ifdef __GNUC__
  /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
     set to 'Yes') calls __io_putchar() */
  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */

#define TEAT_UART_CHAN      UART0
void NVIC_Configuration(void);
void UART_Configuration(void);
void GPIO_Configuration(void);

GPIO_TypeDef *GPIOx;
GPIO_InitTypeDef GPIO_InitStruct;

int main(void)
{
	SYSCTRL_APBPeriphClockCmd(SYSCTRL_APBPeriph_UART0 | SYSCTRL_APBPeriph_GPIO,ENABLE);
	SYSCTRL_APBPeriphResetCmd(SYSCTRL_APBPeriph_UART0,ENABLE);
	
	UART_Configuration();
	NVIC_Configuration();
	
	printf("MegaHunt SCPU GPIO Demo V1.0.\r\n");
        
	while(1)
	{
		uint8_t tmpUartRece = 0;
		int32_t tmpIOOptFlag = 0;

LABLE:
		printf("select Test GPIO:\n");
		printf("1:GPIOA 2:GPIOB 3:GPIOC 4:GPIOD\n");
		while(TRUE)
		{	
			if(UART_GetLineStatus(TEAT_UART_CHAN) & UART_LINE_STATUS_RX_RECVD)
			{
				GPIOx = NULL;
				switch(UART_ReceiveData(TEAT_UART_CHAN))
				{
				case '1':
					GPIOx = GPIOA;
					break;
				case '2':
					GPIOx = GPIOB;
					break;
				case '3':
					GPIOx = GPIOC;
					break;
				case '4':
					GPIOx = GPIOD;
					break;
				}
				if (GPIOx == NULL)
				{
					printf("GPIO select error\n");
					continue;
				}
				else
				{
					break;
				}
			}
		}
		
		GPIO_InitStruct.GPIO_Pin = GPIO_Pin_All;
		GPIO_InitStruct.GPIO_Remap = GPIO_Remap_1;

		printf("select Test GPIO Mode:\n");
		printf("1:GPIO_Mode_IN_FLOATING\n");
		printf("2:GPIO_Mode_IPU\n");
		printf("3:GPIO_Mode_Out_OD\n");
		printf("4:GPIO_Mode_Out_OD_PU\n");
		printf("5:GPIO_Mode_Out_PP\n");
		
		while(TRUE)
		{	
			if(UART_GetLineStatus(TEAT_UART_CHAN) & UART_LINE_STATUS_RX_RECVD)
			{
				GPIO_InitStruct.GPIO_Mode = 0;
				switch(UART_ReceiveData(TEAT_UART_CHAN))
				{
				case '1':
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
					break;
				case '2':
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;
					break;
				case '3':
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD;
					break;
				case '4':
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD_PU;
					break;
				case '5':
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
					break;
				}

				if (GPIO_InitStruct.GPIO_Mode == 0)
				{
					printf("GPIO_Mode select error\n");
					continue;
				}
				else
				{
					break;
				}
			}
		}

		if (TEAT_UART_CHAN == UART0 && GPIOx == GPIOA)
		{
			GPIO_InitStruct.GPIO_Pin = GPIO_Pin_All & (~GPIO_Pin_0 & ~GPIO_Pin_1);
		}
		else if (TEAT_UART_CHAN == UART1 && GPIOx == GPIOD)
		{
			GPIO_InitStruct.GPIO_Pin = GPIO_Pin_All & (~GPIO_Pin_4 & ~GPIO_Pin_5);
		}
		else
		{
			GPIO_InitStruct.GPIO_Pin = GPIO_Pin_All;
		}
		
		GPIO_Init(GPIOx,&GPIO_InitStruct);

		printf("set 0~F Set and Reset GPIO\n");
		while(TRUE)
		{
			if(UART_GetLineStatus(TEAT_UART_CHAN) & UART_LINE_STATUS_RX_RECVD)
			{
				tmpUartRece = UART_ReceiveData(TEAT_UART_CHAN);
				switch(tmpUartRece)
				{
				case '0':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_0);
                            tmpIOOptFlag = 0;
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_0);
                            tmpIOOptFlag = 1;
						}
					}
					break;
				case '1':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_1);
                            tmpIOOptFlag = 0;
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_1);
                            tmpIOOptFlag = 1;
						}
					}
					break;
				case '2':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_2);
                            tmpIOOptFlag = 0;
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_2);
                            tmpIOOptFlag = 1;
						}
					}
					break;
				case '3':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_3);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_3);
						}
					}
					break;
				case '4':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_4);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_4);
						}
					}
					break;
				case '5':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_5);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_5);
						}
					}
					break;
				case '6':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_6);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_6);
						}
					}
					break;
				case '7':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_7);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_7);
						}
					}
					break;
				case '8':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_8);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_8);
						}
					}
					break;
				case '9':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_9);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_9);
						}
					}
					break;
				case 'A':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_10);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_10);
						}
					}
					break;
				case 'B':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_11);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_11);
						}
					}
					break;
				case 'C':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_12);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_12);
						}
					}
					break;
				case 'D':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_13);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_13);
						}
					}
					break;
				case 'E':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_14);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_14);
						}
					}
					break;
				case 'F':
					{
						if (tmpIOOptFlag)
						{
							GPIO_SetBits(GPIOx, GPIO_Pin_15);
						} 
						else
						{
							GPIO_ResetBits(GPIOx, GPIO_Pin_15);
						}
					}
					break;
				case 'S':
					{
						tmpIOOptFlag = 1;
						break;
					}
				case 'R':
					{
						tmpIOOptFlag = 0;
						break;
					}
				case 'O':
					{
						goto LABLE;
						break;
					}
				}
			}
		}

	
	}
	
}

void NVIC_Configuration(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;

//	NVIC_SetVectorTable(NVIC_VectTab_RAM,0);
	NVIC_SetPriorityGrouping(NVIC_PriorityGroup_3);
	
	NVIC_InitStructure.NVIC_IRQChannel = UART0_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
    
    NVIC_InitStructure.NVIC_IRQChannel = UART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
}


void UART_Configuration(void)
{
	UART_InitTypeDef UART_InitStructure;
	
	if (TEAT_UART_CHAN == UART0)
	{
		GPIO_PinRemapConfig(GPIOA, GPIO_Pin_0 | GPIO_Pin_1, GPIO_Remap_0);	
	}
	else if (TEAT_UART_CHAN == UART1)
	{
		GPIO_PinRemapConfig(GPIOD, GPIO_Pin_4 | GPIO_Pin_5, GPIO_Remap_0);
	}

	UART_InitStructure.UART_BaudRate = 115200;
	UART_InitStructure.UART_WordLength = UART_WordLength_8b;
	UART_InitStructure.UART_StopBits = UART_StopBits_1;
	UART_InitStructure.UART_Parity = UART_Parity_No;

	UART_Init(TEAT_UART_CHAN, &UART_InitStructure);
}


//Retarget Printf
int SER_PutChar (int ch) {

	while(!UART_IsTXEmpty(TEAT_UART_CHAN));
	UART_SendData(TEAT_UART_CHAN, (uint8_t) ch);

	return ch;
}

int fputc(int c, FILE *f)
{
	/* Place your implementation of fputc here */
	/* e.g. write a character to the USART */
	if (c == '\n')  {
		SER_PutChar('\r');
	}
	return (SER_PutChar(c));
}


#ifdef  USE_FULL_ASSERT

/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t* file, uint32_t line)
{ 
	/* User can add his own implementation to report the file name and line number,
	 ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

	/* Infinite loop */
	while (1)
	{
	}
}
#endif






